home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update15.zoo / lib / diffs < prev    next >
Encoding:
Text File  |  1992-02-04  |  46.8 KB  |  1,874 lines
  1. *** 1.63    1992/01/14 18:46:50
  2. --- Changelo    1992/02/04 17:15:53
  3. ***************
  4. *** 2620,2622 ****
  5. --- 2620,2786 ----
  6.       the next's. make adjustments to unlink_handler.
  7.   
  8.   ---------------------------- Patchlevel 74 ---------------------------
  9. + 
  10. + scanf.c:: Michael Ritzert
  11. +     - incorrect return value if fewer data items than specified
  12. +     could be read: the supplied _scanf always returns -1 in this case.
  13. +     Instead, it should return EOF if the error occured before 
  14. +     the first data item to be read and the number of items
  15. +         read with success later on.
  16. +     - the %c format passes the character following the one to be read.
  17. + 
  18. + fscanf.c:: ++jrb
  19. +     #define fungetc to ungetc for pre Ansi sunOS 4.0.*
  20. + 
  21. + ctype.[ch]:: andreas
  22. +     allow negative characters (also handles 0xff correctly)
  23. + 
  24. + fopen/fdopen:: andreas
  25. +     set errno to EMFILE if there are no more FILE slots free
  26. +      (gawk uses it)
  27. + 
  28. + fputc:: andreas
  29. +     don't return EOF if c == (signed char)0xff
  30. + 
  31. + malloc.c:: andreas
  32. +     split memory didn't work
  33. +     the memory allocation routines if using the split memory
  34. +     model, sbrk can return values which are out of order, due to switching
  35. +     from system heap to own heap.
  36. + 
  37. + lstat:: andreas
  38. +     unx2dos already stored the link flags in __link_flags; no
  39. +      need to call unx2dos twice
  40. + 
  41. + system:: andreas
  42. +     command line argument can be arbitrary long, hope no longer
  43. +     than BUFSIZ
  44. + 
  45. + unx2dos:: andreas
  46. +     the link contents can be a full pathname in symbolic links
  47. + 
  48. + write.c:: andreas
  49. +     handle chars with high bit set correctly
  50. + 
  51. + fcntl.h:: andreas
  52. +     GEMDOS returns file handles <= 80 (for TOS 1.4, don't know
  53. +     about newer TOS's)
  54. + 
  55. + main.c:: andreas
  56. +     indices into __open_stat were mixed with file handles.
  57. + 
  58. + system.c:: frank
  59. +     skip over quotes.
  60. + 
  61. + pwd.h, getpw.c:: frank, ++jrb
  62. +     adjust types for uid and gid. they should be uid_t and gid_t 
  63. +     respectively.
  64. + 
  65. + pipe.c:: ++jrb
  66. +     cleanup: get rid of -Wall warnings.
  67. + 
  68. + localtim.c:: ++jrb
  69. +     if the time given is weird, return the epoch. this is a questionable
  70. + fix: we used to return NULL, but that seems to cause problems, as things
  71. + that use the pointer returned by localtime() never seem to check for
  72. + the possibility of a NULL. my handy ANSI reference is mum on what to
  73. + do when the  time given is weird. this was causing zoo to blow up in
  74. + zoosrc/nixtime.i when trying to archive files with weird timestamps (some
  75. + people seem to have a weird kbd processor that time warps!).
  76. + 
  77. + ostruct.h:: Bill Shroka
  78. +     NEW file. it contains most of the popular OS (non Aes/Vdi) structures
  79. +     Thanks bill: this is a good beginning to this file, it more or
  80. +     less corresponds to franks Documentation/varcard.tex. We can add
  81. +     on more stuff as needed.
  82. + 
  83. + osbind.h:: Bill Shroka
  84. +     use <ostruct.h>
  85. + 
  86. + pipe.c:: ++jrb
  87. +     All fprintf() in here needed to be conditional upon DEBUG. Thanks
  88. + to michal for finding this. his code was unexpectedly pulling in all
  89. + kinds of stuff due to external references tp fprintf() here.
  90. + 
  91. + pipe.c, close.c:: ++jrb
  92. +     take out direct call to pipeclose() from close to avoid pulling
  93. + in all the pipe stuff into programs that dont use pipes. instead
  94. + go thru a pointer that is initially nulled, and if the program calles
  95. + pipe() is patched in with the address of pipeclose(). this way only the code
  96. + that actually uses pipes will link in the pipe code.
  97. + 
  98. + crt0.c:: ++jrb
  99. +     cleanup.
  100. + 
  101. + float.h: mjr
  102. +     cleanup values to better reflect reality.
  103. + 
  104. + 
  105. + ***** NOTE ***** ***** NOTE ***** ***** NOTE ***** ***** NOTE *****
  106. + 
  107. + _addsubd.s _addsubs.s _divdf3.s _divsf3.s _extends.s _fixdfsi.s _fxunsd.s
  108. + _floatsi.s _muldf3.s _mulsf3.s _normdf.s _normsf.s _truncdf.s modf.s:: mjr
  109. + 
  110. +     NOTE: these .S files replaced with corresponding .CPP files.
  111. + 
  112. + 
  113. + mincl:: ++jrb
  114. +     adjust targets for above
  115. + 
  116. + math-68881.h:: ++mjr
  117. +     removed any error checking code (use the library versions if
  118. +     error checking is required)
  119. + 
  120. + frexp:: ++mjr
  121. +     y = frexp(0,ip) now corectly returns 0 both in y and *ip
  122. + 
  123. +     sfp004 - version written but not tested due to lack of hardware
  124. +     my sfp004 board died, so only a "plausibility test" could be made.
  125. +     most probable sources of bugs: 
  126. +     the fscale instruction has been inserted to the old function body 
  127. +     after the dead of the board.
  128. +     The test if the 1st arg is 0, too.
  129. + 
  130. + doprnt.c:: ++mjr
  131. +     NAN and INFINITY conditions are caught by analysing only the most
  132. +     significant long word (uniqe).
  133. +     this also serves as a workaround to the conversion bug of 
  134. +     gcc-as 
  135. +     (DBL_MAX is converted to 0x7ff00000 0x00000002
  136. +             instead of   0x7fefffff 0xfffffffe
  137. +     ) which sometimes causes doprnt to crash.
  138. + 
  139. + _fixdfsi.cpp:
  140. + _fixunsdfsi.cpp:
  141. +     optional error checking added. 
  142. +     All three situations (no fpu, sfp004, TT) supported.
  143. + 
  144. + _normsf.cpp:
  145. + _divdf3.cpp:
  146. + _divsf3.cpp:
  147. +     returns signed infinity in case of an exception.
  148. +     if option ERROR_CHECK is enabled:
  149. +     _errno is set to ERANGE.
  150. +     The EDOM situation 0/0 is not tested explicitly.
  151. +     All three situations (no fpu, sfp004, TT) supported.
  152. + 
  153. + _normdf.cpp:
  154. +     if option ERROR_CHECK is enabled:
  155. +     _errno is set to ERANGE.
  156. +     message is printed.
  157. +     value of ERANGE corrected to 62 (was 34 = EPATH)
  158. + 
  159. + ldexp.cpp:
  160. +     value of ERANGE corrected to 62 (was 34 = EPATH)
  161. +     optional ERROR_CHECK inserted.
  162. +     underflow is no longer considered an error condition to
  163. +     stay consistent with pml.
  164. +     if ERROR_CHECK is enabled, a message is printed on overflow.    
  165. + 
  166. + _addsubd.cpp:
  167. + _addsubs.cpp:
  168. + _muldf3.cpp:
  169. + _mulsf3.cpp:    ++mjr:
  170. +     sfp004 code and software floating point code merged into one file.
  171. + 
  172. + ---------------------------- Patchlevel 75 ---------------------------
  173. *** 1.50    1991/12/26 15:53:59
  174. --- PatchLev.h    1992/02/04 17:15:54
  175. ***************
  176. *** 1,5 ****
  177.   
  178. ! #define    PatchLevel "74"
  179.   
  180.   /*
  181.    *
  182. --- 1,5 ----
  183.   
  184. ! #define    PatchLevel "75"
  185.   
  186.   /*
  187.    *
  188. *** 1.19    1991/12/26 15:53:59
  189. --- atof.c    1992/02/04 17:16:01
  190. ***************
  191. *** 27,34 ****
  192.    *    the old naive coding is at the end bracketed by ifdef __OLD__.
  193.    *    modeled after peter housels posting on comp.os.minix.
  194.    *    thanks peter!
  195. !  *        ++jrb
  196.    */
  197.   #if !(defined(unix) || defined(minix))
  198.   #include <stddef.h>
  199.   #include <stdlib.h>
  200. --- 27,38 ----
  201.    *    the old naive coding is at the end bracketed by ifdef __OLD__.
  202.    *    modeled after peter housels posting on comp.os.minix.
  203.    *    thanks peter!
  204. !  *
  205. !  *    mjr: 68881 version added
  206.    */
  207. + 
  208. + #if !defined (__M68881__) && !defined (sfp004)
  209. + 
  210.   #if !(defined(unix) || defined(minix))
  211.   #include <stddef.h>
  212.   #include <stdlib.h>
  213. ***************
  214. *** 240,246 ****
  215.       register short e     = 0;
  216.       double       zero = 0.0;
  217.       const char        *tmp;
  218. ! 
  219.       assert ((s != NULL));
  220.   
  221.       if(endptr != NULL) *endptr = (char *)s;
  222. --- 244,250 ----
  223.       register short e     = 0;
  224.       double       zero = 0.0;
  225.       const char        *tmp;
  226. !  
  227.       assert ((s != NULL));
  228.   
  229.       if(endptr != NULL) *endptr = (char *)s;
  230. ***************
  231. *** 281,287 ****
  232.       {
  233.       if(*++s != '\0') /* skip e|E|d|D */
  234.       {  /* ! ([s]xxx[.[yyy]]e)  */
  235. !         tmp = s;
  236.           while(Isspace(*s)) s++; /* Ansi allows spaces after e */
  237.           if(*s != '\0')
  238.           { /*  ! ([s]xxx[.[yyy]]e[space])  */
  239. --- 285,291 ----
  240.       {
  241.       if(*++s != '\0') /* skip e|E|d|D */
  242.       {  /* ! ([s]xxx[.[yyy]]e)  */
  243. !          tmp = s;
  244.           while(Isspace(*s)) s++; /* Ansi allows spaces after e */
  245.           if(*s != '\0')
  246.           { /*  ! ([s]xxx[.[yyy]]e[space])  */
  247. ***************
  248. *** 324,453 ****
  249.       return strtod(s, (char **)NULL);
  250.   }
  251.   
  252. - #ifdef TEST
  253. - #ifdef __MSHORT__
  254. - #error "please run this test in 32 bit int mode"
  255. - #endif
  256. - 
  257. - #define NTEST 10000L
  258. - 
  259. - #ifdef unix
  260. - #ifdef __MSHORT__
  261. - #define    RAND_MAX    (0x7FFF)    /* maximum value from rand() */
  262. - #else
  263. - #define    RAND_MAX    (0x7FFFFFFFL)    /* maximum value from rand() */
  264. - #endif
  265. - #endif
  266. - 
  267. - main()
  268. - {
  269. -     
  270. -     double expected, result, e, max_abs_err;
  271. -     char buf[128];
  272. -     register long i, errs;
  273. -     register int s;
  274. - #ifdef __STDC__
  275. -     double atof(const char *);
  276. -     int rand(void);
  277. - #else
  278. -     extern double atof();
  279. -     extern int rand();
  280. - #endif
  281. - 
  282. - #if 0
  283. -     expected = atof("3.14159265358979e23");
  284. -     expected = atof("3.141");
  285. -     expected = atof(".31415"); 
  286. -     printf("%f\n\n", expected);
  287. -     expected = atof("3.1415"); 
  288. -     printf("%f\n\n", expected);
  289. -     expected = atof("31.415"); 
  290. -     printf("%f\n\n", expected);
  291. -     expected = atof("314.15"); 
  292. -     printf("%f\n\n", expected);
  293. - 
  294. -     expected = atof(".31415"); 
  295. -     printf("%f\n\n", expected);
  296. -     expected = atof(".031415"); 
  297. -     printf("%f\n\n", expected);
  298. -     expected = atof(".0031415"); 
  299. -     printf("%f\n\n", expected);
  300. -     expected = atof(".00031415"); 
  301. -     printf("%f\n\n", expected);
  302. -     expected = atof(".000031415"); 
  303. -     printf("%f\n\n", expected);
  304. - 
  305. -     expected = atof("-3.1415e-9"); 
  306. -     printf("%20.15e\n\n", expected);
  307. - 
  308. -     expected = atof("+3.1415e+009"); 
  309. -     printf("%20.15e\n\n", expected);
  310. - #endif
  311. - 
  312. -     expected = atof("+3.123456789123456789"); 
  313. -     printf("%30.25e\n\n", expected);
  314. - 
  315. -     expected = atof(".000003123456789123456789"); 
  316. -     printf("%30.25e\n\n", expected);
  317. - 
  318. -     expected = atof("3.1234567891234567890000000000"); 
  319. -     printf("%30.25e\n\n", expected);
  320. - 
  321. -     expected = atof("9.22337999999999999999999999999999999999999999"); 
  322. -     printf("%47.45e\n\n", expected);
  323. - 
  324. -     expected = atof("1.0000000000000000000"); 
  325. -     printf("%25.19e\n\n", expected);
  326. - 
  327. -     expected = atof("1.00000000000000000000"); 
  328. -     printf("%26.20e\n\n", expected);
  329. - 
  330. -     expected = atof("1.000000000000000000000"); 
  331. -     printf("%27.21e\n\n", expected);
  332. - 
  333. -     expected = atof("1.000000000000000000000000"); 
  334. -     printf("%30.24e\n\n", expected);
  335. - 
  336. -  
  337. - #if 0
  338. -     expected = atof("1.7e+308");
  339. -     if(errno != 0)
  340. -     {
  341. -     printf("%d\n", errno);
  342. -     }
  343. -     else    printf("1.7e308 OK %g\n", expected);
  344. -     expected = atof("1.797693e308");    /* anything gt looses */
  345. -     if(errno != 0)
  346. -     {
  347. -     printf("%d\n", errno);
  348. -     }
  349. -     else    printf("Max OK %g\n", expected);
  350. -     expected = atof("2.225073858507201E-307");
  351. -     if(errno != 0)
  352. -     {
  353. -     printf("%d\n", errno, expected);
  354. -     }
  355. -     else    printf("Min OK %g\n", expected);
  356. - #endif
  357. -     
  358. -     max_abs_err = 0.0;
  359. -     for(errs = 0, i = 0; i < NTEST; i++)
  360. -     {
  361. -     expected = (double)(s = rand()) / (double)rand();
  362. -     if(s > (RAND_MAX >> 1)) expected = -expected;
  363. -     sprintf(buf, "%.14e", expected);
  364. -     result = atof(buf);
  365. -     e = (expected == 0.0) ? result : (result - expected)/expected;
  366. -     if(e < 0) e = (-e);
  367. -     if(e > 1.0e-6) 
  368. -     {
  369. -         errs++; printf("%.14e %s %.14e (%.14e)\n", expected, buf, result, e);
  370. -     }
  371. -     if (e > max_abs_err) max_abs_err = e;
  372. -     }
  373. -     printf("%ld Error(s), Max abs err %.14e\n", errs, max_abs_err);
  374. - }
  375. - #endif /* TEST */
  376.   
  377.   /* old naive coding */
  378.   #ifdef __OLD__
  379. --- 328,333 ----
  380. ***************
  381. *** 567,569 ****
  382. --- 447,847 ----
  383.       return r;
  384.   }
  385.   #endif /* __OLD__ */
  386. + 
  387. + #else    __M68881__ || sfp004
  388. + 
  389. + #if 0
  390. + #ifndef    sfp004
  391. + # define _M68881    /* use the predefined inline functions                */
  392. + #endif    sfp004
  393. + #endif 0
  394. + 
  395. + /* M.R's kludgy atof --- 881 version.                        */
  396. + /*     uses long integer accumulators and extended precision to put them    */
  397. + /*    together in the fpu. The conversion long to extended is done completely    */
  398. + /*    on the 881.                                */
  399. + /*    using extended precision in _float_ avoids rounding errors.        */
  400. + 
  401. + /* 12.7.1989, 11.10.90, 28.1.91, 24.11.91                    */
  402. + /* On overflow, only +-infinity is returned (the 68881's default).        */
  403. + /* 24.11.91: return +-MAXDOUBLE instead of +- INFINITY or NAN            */
  404. + /*           set errno to ERANGE/EDOM                        */
  405. + 
  406. + # include <ctype.h>
  407. + # include <stdio.h>
  408. + # include <float.h>
  409. + # include <math.h>
  410. + # include <errno.h>
  411. + # include "flonum.h"
  412. + 
  413. + double atof( const char * );
  414. + double strtod( const char *, const char ** );
  415. + double _Float_( long, long, long, long );
  416. + 
  417. + # define    true 1
  418. + # define false 0
  419. + # define CharIsDigit ( isdigit(*Text) )
  420. + # define Digit ((*Text-'0'))
  421. + 
  422. + #if 0
  423. + static unsigned long
  424. +     __notanumber[2] = { 0x7fffffffL, 0xffffffffL }; /* ieee NAN */
  425. + # define NAN  (*((double *)&__notanumber[0]))
  426. + # endif 0
  427. + 
  428. + # define ten_mul(X)    ((((X) << 2) + (X)) << 1)
  429. + 
  430. + double strtod( const char * Save, const char ** Endptr )
  431. + {
  432. +   register int Count; int Negative = false, ExpNegative = false;
  433. + 
  434. +   double Value;
  435. +   union double_di * l_Value;
  436. +   register long Exponent, Exp_Temp;
  437. +   register long Value_1, Value_2;
  438. +   register char c;
  439. +   register char * Text;
  440. +   register char * Places;
  441. +   char Buffer[15];
  442. + 
  443. +   l_Value = (union double_di *) &Value;
  444. + 
  445. +   Text = Save;
  446. +   Places = Buffer;
  447. + 
  448. +   /* skip over leading whitespace */
  449. +   while (isspace(*Text)) Text++;
  450. + 
  451. +   if (*Text == '-') {
  452. +     Negative = true;
  453. +     Text++;
  454. +   } else
  455. +   if (*Text == '+') {
  456. +     Negative = false;
  457. +     Text++;
  458. +   } else
  459. +   if( *Text == 0 ) {
  460. +     if( Endptr != NULL ) *Endptr = Text;
  461. +     return 0.0;
  462. +   }
  463. + 
  464. +   /* Process the 'f'-part                             */
  465. +   /* ignore any digit beyond the 15th                         */
  466. +   /* BUG: may overflow if more than 10 digits precede the '.'            */
  467. +   /* to cure use to accumulators as is being done for the digits after        */
  468. +   /* the '.'.                                    */
  469. + 
  470. +   Exp_Temp = 0;            /* needed later on for the exponential part    */
  471. +   Value_1 = 0; Value_2 = 0; Count = 0; Exponent = 0;
  472. +   while( CharIsDigit ) {    /* process digits before '.'            */
  473. +     if( Count < 15 ) {
  474. +       Count++;
  475. +       *Places++ = Digit;
  476. +     }
  477. +     Text++;
  478. +   }
  479. +   if ( *Text == '.') {
  480. +     Text++;
  481. +     while( CharIsDigit ) {    /* process digits after '.'            */
  482. +       if( Count < 15 )    {
  483. +         Count++;
  484. +             *Places++ = Digit;
  485. +         Exponent--;
  486. +       }
  487. +       Text++;
  488. +     }
  489. +   }
  490. +   Places = Buffer;
  491. + 
  492. +   /* Now, Places points to a vector of <= 15 digits                */
  493. +   /* text points to the position immediately after the end of the mantissa    */
  494. +   /* Value_2 will contain the equiv. of the 8 least significant digits, while    */
  495. +   /* Value_1 will contain the equiv. of the 7 most significant digits (if any)    */
  496. +   /* and therefore has to be multiplied by 10^8                    */
  497. +   /* no overflow possible in the temporary buffers                */
  498. + 
  499. +   while( Count > 8 )    {
  500. +       Value_1 = ten_mul( Value_1 );      Value_1 += *Places++;
  501. +       Count--;
  502. +   }
  503. +   while( Count > 0 )    {
  504. +       Value_2 = ten_mul( Value_2 );      Value_2 += *Places++;
  505. +       Count--;
  506. +   }
  507. + 
  508. +   /* 'e'-Part */
  509. +   if ( *Text == 'e' || *Text == 'E' || *Text == 'd' || *Text == 'D' ) {
  510. + 
  511. +     char * Tail = Text;
  512. +     Text++;
  513. + 
  514. +     /* skip over whitespace since ANSI allows space after e|E|d|D        */
  515. +     while (isspace(*Text)) Text++;
  516. + 
  517. +     if ( * Text == '-' ) {
  518. +         ExpNegative = true;
  519. +         Text++;
  520. +     } else
  521. +     if( * Text == '+' ) {
  522. +         ExpNegative = false;
  523. +         Text++;
  524. +     }
  525. +     if( !CharIsDigit ) {
  526. +         *Endptr = Tail;    /* take the 'e|E|d|D' as part of the characters    */
  527. +         goto Ende;        /* following the number            */
  528. +     } else {
  529. +     /* Exponents may have at most 3 digits, everything beyond this will be    */
  530. +     /* silently ignored                            */
  531. +         Count = 0;
  532. +         while( CharIsDigit && (Count < 3) ) {
  533. +             Exp_Temp = ten_mul( Exp_Temp ); Exp_Temp += Digit;
  534. +               Count++;
  535. +             Text++;
  536. +         }
  537. +         if( ExpNegative ) Exp_Temp = -Exp_Temp;
  538. +         Exponent += Exp_Temp;
  539. +      }
  540. +   }
  541. +   Value = _Float_( Value_1, Exponent+8L, Value_2, Exponent );
  542. + 
  543. +   if( Endptr != NULL ) *Endptr = Text;
  544. +   if( (l_Value -> i[0]) >= 0x7ff00000U )    { /* INFINITY or NAN        */
  545. +     fprintf(stderr," strtod: OVERFLOW error\n");
  546. +     errno = ERANGE;
  547. +     Value = DBL_MAX;
  548. +   }
  549. + 
  550. + Ende:    
  551. +   if( Negative ) {
  552. +     Value = -Value;
  553. +   }
  554. +   return( Value );
  555. + 
  556. + # if 0
  557. + Error:
  558. +   fputs("\njunk number \"",stderr); fputs(Save,stderr); 
  559. +   fputs("\" --- returning NAN\n",stderr);
  560. +   errno = ERANGE;
  561. +   if( Endptr != NULL ) *Endptr = Text;
  562. +   return(NAN);    /* == Not A Number (NAN) */
  563. + # endif
  564. + }
  565. + 
  566. + double atof( const char * Text )
  567. + {
  568. +     return(strtod(Text,(char **)NULL));
  569. + }
  570. + 
  571. + /*
  572. +  * double _Float_( long Value_1, long Exponent_1, long Value_2, long Exponent_2 )
  573. +  *
  574. +  * merges the accumulators Value_1, Value_2 and the Exponent to a double
  575. +  * precision float
  576. +  * called by strtod()
  577. +  *
  578. +  * does all floating point computations with extended precision on the fpu
  579. +  */
  580. + 
  581. + #endif __M68881__ || sfp004
  582. + 
  583. + #ifdef __M68881__
  584. + asm(
  585. + ".even
  586. + .text
  587. +     .globl __Float_
  588. + __Float_:
  589. +     ftentoxl    a7@(8),fp1        | load Exponent_1
  590. +     ftentoxl    a7@(16),fp2        | load Exponent_2
  591. +     fmull        a7@(12),fp2        | fmull Value_2 -> fp2
  592. +     fmull        a7@(4),fp1        | fmull Value_1 -> fp1
  593. +     faddx        fp2,fp1
  594. +     fmoved        fp1,a7@-        | fmoved fp1 -> d0/d1
  595. +     moveml        a7@+,d0-d1
  596. +      rts
  597. + ");
  598. + #endif    __M68881
  599. + #ifdef    sfp004
  600. + 
  601. + asm("| mjr, 30.1.1991
  602. + |
  603. + | base =    0xfffa50
  604. + |      the fpu addresses are taken relativ to 'base':
  605. + |
  606. + | a0: fpu base address
  607. + |
  608. + 
  609. + | waiting loop ...
  610. + |
  611. + | wait:
  612. + | ww:    cmpiw    #0x8900,a0@(resp)
  613. + |     beq    ww
  614. + | is coded directly by
  615. + |    .long    0x0c688900, 0xfff067f8 (a0)
  616. + | and
  617. + | www:    tst.w    a0@(resp)
  618. + |    bmi.b    www
  619. + | is coded by
  620. + |    .word    0x4a68,0xfff0,0x6bfa        | test
  621. + |
  622. + 
  623. + comm =     -6
  624. + resp =    -16
  625. + zahl =      0
  626. + 
  627. +     .globl __Float_
  628. + .even
  629. + .text
  630. + __Float_:
  631. +     lea    0xfffa50,a0            | fpu address
  632. + 
  633. +     movew    #0x4092,a0@(comm)        | ftentoxl -> fp1
  634. +     .long    0x0c688900, 0xfff067f8
  635. +     movel    a7@(8),a0@            | load Exponent_1
  636. + 
  637. +     movew    #0x4112,a0@(comm)        | ftentoxl -> fp2
  638. +     .long    0x0c688900, 0xfff067f8
  639. +     movel    a7@(16),a0@            | load Exponent_2
  640. + 
  641. +     movew    #0x4123,a0@(comm)        | fmull Value_2 -> fp2
  642. +     .long    0x0c688900, 0xfff067f8
  643. +     movel    a7@(12),a0@            | load Value_2
  644. + 
  645. +     movew    #0x40a3,a0@(comm)        | fmull Value_1 -> fp1
  646. +     .long    0x0c688900, 0xfff067f8
  647. +     movel    a7@(4),a0@            | load Value_1
  648. + 
  649. +     movew    #0x08a2,a0@(comm)        | faddx fp2 -> fp1
  650. +     .word    0x4a68,0xfff0,0x6bfa        | test
  651. + 
  652. +     movew    #0x7480,a0@(comm)        | fmoved fp1 -> d0/d1
  653. +     .long    0x0c688900, 0xfff067f8
  654. +     movel    a0@,d0
  655. +     movel    a0@,d1
  656. +      rts
  657. + ");
  658. + #endif    sfp004
  659. + 
  660. + #ifdef TEST
  661. + #if 0
  662. + #ifdef __MSHORT__
  663. + #error "please run this test in 32 bit int mode"
  664. + #endif
  665. + #endif
  666. + 
  667. + #define NTEST 10000L
  668. + 
  669. + #ifdef __MSHORT__
  670. + # define    RAND_MAX    (0x7FFF)    /* maximum value from rand() */
  671. + #else
  672. + # define    RAND_MAX    (0x7FFFFFFFL)    /* maximum value from rand() */
  673. + #endif
  674. + 
  675. + main()
  676. + {
  677. +     
  678. +     double expected, result, e, max_abs_err;
  679. +     char buf[128];
  680. +     register long i, errs;
  681. +     register long s;
  682. + #ifdef __STDC__
  683. +     double atof(const char *);
  684. +     int rand(void);
  685. + #else
  686. +     extern double atof();
  687. +     extern int rand();
  688. + #endif
  689. + 
  690. + #if 0
  691. +     expected = atof("3.14159265358979e23");
  692. +     expected = atof("3.141");
  693. +     expected = atof(".31415"); 
  694. +     printf("%f\n\n", expected);
  695. +     expected = atof("3.1415"); 
  696. +     printf("%f\n\n", expected);
  697. +     expected = atof("31.415"); 
  698. +     printf("%f\n\n", expected);
  699. +     expected = atof("314.15"); 
  700. +     printf("%f\n\n", expected);
  701. + 
  702. +     expected = atof(".31415"); 
  703. +     printf("%f\n\n", expected);
  704. +     expected = atof(".031415"); 
  705. +     printf("%f\n\n", expected);
  706. +     expected = atof(".0031415"); 
  707. +     printf("%f\n\n", expected);
  708. +     expected = atof(".00031415"); 
  709. +     printf("%f\n\n", expected);
  710. +     expected = atof(".000031415"); 
  711. +     printf("%f\n\n", expected);
  712. + 
  713. +     expected = atof("-3.1415e-9"); 
  714. +     printf("%20.15e\n\n", expected);
  715. + 
  716. +     expected = atof("+3.1415e+009"); 
  717. +     printf("%20.15e\n\n", expected);
  718. + #endif
  719. + 
  720. +     expected = atof("+3.123456789123456789"); 
  721. +     printf("%30.25e\n\n", expected);
  722. + 
  723. +     expected = atof(".000003123456789123456789"); 
  724. +     printf("%30.25e\n\n", expected);
  725. + 
  726. +     expected = atof("3.1234567891234567890000000000"); 
  727. +     printf("%30.25e\n\n", expected);
  728. + 
  729. +     expected = atof("9.22337999999999999999999999999999999999999999"); 
  730. +     printf("%47.45e\n\n", expected);
  731. + 
  732. +     expected = atof("1.0000000000000000000"); 
  733. +     printf("%25.19e\n\n", expected);
  734. + 
  735. +     expected = atof("1.00000000000000000000"); 
  736. +     printf("%26.20e\n\n", expected);
  737. + 
  738. +     expected = atof("1.000000000000000000000"); 
  739. +     printf("%27.21e\n\n", expected);
  740. + 
  741. +     expected = atof("1.000000000000000000000000"); 
  742. +     printf("%30.24e\n\n", expected);
  743. + 
  744. +  
  745. + #if 0
  746. +     expected = atof("1.7e+308");
  747. +     if(errno != 0)
  748. +     {
  749. +     printf("%d\n", errno);
  750. +     }
  751. +     else    printf("1.7e308 OK %g\n", expected);
  752. +     expected = atof("1.797693e308");    /* anything gt looses */
  753. +     if(errno != 0)
  754. +     {
  755. +     printf("%d\n", errno);
  756. +     }
  757. +     else    printf("Max OK %g\n", expected);
  758. +     expected = atof("2.225073858507201E-307");
  759. +     if(errno != 0)
  760. +     {
  761. +     printf("%d\n", errno, expected);
  762. +     }
  763. +     else    printf("Min OK %g\n", expected);
  764. + #endif
  765. +     
  766. +     max_abs_err = 0.0;
  767. +     for(errs = 0, i = 0; i < NTEST; i++)
  768. +     {
  769. +     expected = (double)(s = rand()) / (double)rand();
  770. +     if(s > (RAND_MAX >> 1)) expected = -expected;
  771. +     sprintf(buf, "%.14e", expected);
  772. +     result = atof(buf);
  773. +     e = (expected == 0.0) ? result : (result - expected)/expected;
  774. +     if(e < 0) e = (-e);
  775. +     if(e > 1.0e-6) 
  776. +     {
  777. +         errs++; printf("%.14e %s %.14e (%.14e)\n", expected, buf, result, e);
  778. +     }
  779. +     if (e > max_abs_err) max_abs_err = e;
  780. +     }
  781. +     printf("%ld Error(s), Max abs err %.14e\n", errs, max_abs_err);
  782. + }
  783. + #endif /* TEST */
  784. *** 1.13    1991/12/26 15:53:59
  785. --- close.c    1992/02/04 17:16:05
  786. ***************
  787. *** 9,15 ****
  788.   #include    <device.h>
  789.   #include    <stdlib.h>
  790.   
  791. ! __EXTERN int pipeclose __PROTO((int fd));
  792.   
  793.   #ifdef DEBUG
  794.   #include <stdio.h>
  795. --- 9,15 ----
  796.   #include    <device.h>
  797.   #include    <stdlib.h>
  798.   
  799. ! int (*pipeclose_p) __PROTO((int fd)) = 0;
  800.   
  801.   #ifdef DEBUG
  802.   #include <stdio.h>
  803. ***************
  804. *** 38,44 ****
  805.           rval = close(oldfd);
  806.           }
  807.           else 
  808. !         rval = pipeclose(oldfd);
  809.           return(rval);
  810.       }
  811.       else 
  812. --- 38,44 ----
  813.           rval = close(oldfd);
  814.           }
  815.           else 
  816. !         rval = (*pipeclose_p)(oldfd);
  817.           return(rval);
  818.       }
  819.       else 
  820. *** 1.18    1991/12/26 15:53:59
  821. --- crt0.c    1992/02/04 17:16:05
  822. ***************
  823. *** 240,246 ****
  824.           _stksize = _initial_stack;
  825.       }
  826.       
  827. !     if((_stksize < 0) && (_stksize != -1L))
  828.       {
  829.           _heapbase = (void *) ((long)bp->p_tbase + m);
  830.           _stksize = -_stksize - 1;
  831. --- 240,246 ----
  832.           _stksize = _initial_stack;
  833.       }
  834.       
  835. !     if((_stksize <  -1L))
  836.       {
  837.           _heapbase = (void *) ((long)bp->p_tbase + m);
  838.           _stksize = -_stksize - 1;
  839. ***************
  840. *** 247,253 ****
  841.           }
  842.           
  843.       if((!_initial_stack) && (_stksize >= -1L))
  844. !         {   /* keep all, malloc from Malloc first, then from own heap */
  845.           _split_mem = 1;
  846.           }
  847.   
  848. --- 247,253 ----
  849.           }
  850.           
  851.       if((!_initial_stack) && (_stksize >= -1L))
  852. !         {   /* malloc from Malloc first, then from own heap */
  853.           _split_mem = 1;
  854.           }
  855.   
  856. *** 1.5    1991/03/13 14:58:25
  857. --- ctype.c    1992/02/04 17:16:06
  858. ***************
  859. *** 12,20 ****
  860.           /* some code uses these as function pointers --  i   */
  861.           /* have seen code that does.                 */
  862.   
  863. ! static unsigned char _myctype[UCHAR_MAX+2] =
  864.       {
  865. -        0,                    /* isXXX(EOF) caught here */
  866.       _CTc, _CTc, _CTc, _CTc,                /* 0x00..0x03 */
  867.       _CTc, _CTc, _CTc, _CTc,                /* 0x04..0x07 */
  868.       _CTc, _CTc|_CTs, _CTc|_CTs, _CTc|_CTs,        /* 0x08..0x0B */
  869. --- 12,19 ----
  870.           /* some code uses these as function pointers --  i   */
  871.           /* have seen code that does.                 */
  872.   
  873. ! unsigned char _ctype[UCHAR_MAX+1] =
  874.       {
  875.       _CTc, _CTc, _CTc, _CTc,                /* 0x00..0x03 */
  876.       _CTc, _CTc, _CTc, _CTc,                /* 0x04..0x07 */
  877.       _CTc, _CTc|_CTs, _CTc|_CTs, _CTc|_CTs,        /* 0x08..0x0B */
  878. ***************
  879. *** 64,71 ****
  880.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xE0..0xEF */
  881.       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  /* 0xF0..0xFF */
  882.       };
  883. - 
  884. - unsigned char *_ctype = &(_myctype[1]);
  885.   
  886.   int toupper(c)
  887.       int c;
  888. --- 63,68 ----
  889. *** 1.8    1991/05/23 14:43:17
  890. --- doprnt.c    1992/02/04 17:16:07
  891. ***************
  892. *** 18,25 ****
  893. --- 18,34 ----
  894.   /*
  895.    * minorly customized for gcc lib
  896.    *    ++jrb
  897. +  * and for the sfp004 as well as the TT's 68881
  898. +  *      mjr++
  899.    */
  900.   
  901. + static unsigned long
  902. +     __notanumber[2] = { 0x7fffffffL, 0xffffffffL }; /* ieee NAN */
  903. + #define NAN  (*((double *)&__notanumber[0]))
  904. + static unsigned long
  905. +     __p_infinity[2] = { 0x7ff00000L, 0x00000000L }; /* ieee NAN */
  906. + #define INF  (*((double *)&__p_infinity[0]))
  907. + 
  908.   #ifdef LIBC_SCCS
  909.   static char sccsid[] = "@(#)doprnt.c    5.37 (Berkeley) 3/26/89";
  910.   #endif /* LIBC_SCCS */
  911. ***************
  912. *** 30,36 ****
  913.   #include <ctype.h>
  914.   #include <string.h>
  915.   #include <limits.h>
  916. ! #include <math.h>
  917.   
  918.   #ifndef __GNUC__    /* gcc lib has these typedefs in sys/types.h */
  919.   typedef unsigned char u_char;
  920. --- 39,45 ----
  921.   #include <ctype.h>
  922.   #include <string.h>
  923.   #include <limits.h>
  924. ! #include    <math.h>    /* mjr++    */
  925.   
  926.   #ifndef __GNUC__    /* gcc lib has these typedefs in sys/types.h */
  927.   typedef unsigned char u_char;
  928. ***************
  929. *** 39,47 ****
  930.   
  931.   /* 11-bit exponent (VAX G floating point) is 308 decimal digits */
  932.   #define    MAXEXP        308
  933.   /* 128 bit fraction takes up 39 decimal digits; max reasonable precision */
  934. ! #define    MAXFRACT    39
  935.   
  936.   #define    DEFPREC        6
  937.   
  938.   #define    BUF        (MAXEXP+MAXFRACT+1)    /* + decimal point */
  939. --- 48,62 ----
  940.   
  941.   /* 11-bit exponent (VAX G floating point) is 308 decimal digits */
  942.   #define    MAXEXP        308
  943. + 
  944.   /* 128 bit fraction takes up 39 decimal digits; max reasonable precision */
  945. ! # define    MAXFRACT    39
  946. ! # define    MAXEXP        308
  947.   
  948. + #if defined (__M68881__) && !defined (sfp004)
  949. + #  include <math-68881.h>    /* mjr: use the inline functions    */
  950. + #endif    __M68881__
  951. + 
  952.   #define    DEFPREC        6
  953.   
  954.   #define    BUF        (MAXEXP+MAXFRACT+1)    /* + decimal point */
  955. ***************
  956. *** 71,79 ****
  957.   #endif
  958.   
  959.   #ifdef __FLOATS__
  960. ! static char *exponent    __PROTO((char *, int, int));
  961. ! static char *round    __PROTO((double, int *, char *, char *, int, char *));
  962. ! static int  cvt        __PROTO((double, int, int, char *, int, char *, char *));
  963.   #endif
  964.   
  965.   #ifdef __GNUC__
  966. --- 86,101 ----
  967.   #endif
  968.   
  969.   #ifdef __FLOATS__
  970. ! # include    "flonum.h"
  971. ! #  if __STDC__
  972. ! static char *exponent(char *, int, int);
  973. ! static char *round(double, int *, char *, char *, int, char *);
  974. ! static int  cvt(double, int, int, char *, int, char *, char *);
  975. ! #  else
  976. ! static char *exponent();
  977. ! static char *round();
  978. ! static int  cvt();
  979. ! #  endif
  980.   #endif
  981.   
  982.   #ifdef __GNUC__
  983. ***************
  984. *** 97,103 ****
  985.       }                                \
  986.       else                            \
  987.       {                                \
  988. !     extern unsigned long __udivsi3(long, long); /* quot = d0, rem = d1 */     \
  989.       do                             \
  990.       {                            \
  991.           __asm__ volatile("        \
  992. --- 119,125 ----
  993.       }                                \
  994.       else                            \
  995.       {                                \
  996. !         extern unsigned long __udivsi3(); /* quot = d0, rem = d1 */     \
  997.       do                             \
  998.       {                            \
  999.           __asm__ volatile("        \
  1000. ***************
  1001. *** 127,133 ****
  1002.       register int cnt;    /* return value accumulator */
  1003.       register int n;        /* random handy integer */
  1004.       register char *t;    /* buffer pointer */
  1005. !     double _double;        /* double precision arguments %[eEfgG] */
  1006.       u_long _ulong;        /* integer arguments %[diouxX] */
  1007.       short base;        /* base for [diouxX] conversion */
  1008.       short dprec;        /* decimal precision in [diouxX] */
  1009. --- 149,158 ----
  1010.       register int cnt;    /* return value accumulator */
  1011.       register int n;        /* random handy integer */
  1012.       register char *t;    /* buffer pointer */
  1013. ! #ifdef    __FLOATS__
  1014. ! /*    double _double;        *//* double precision arguments %[eEfgG] */
  1015. !     union double_di _dd;    /* _double is #defined to be _dd later on */
  1016. ! #endif    __FLOATS__
  1017.       u_long _ulong;        /* integer arguments %[diouxX] */
  1018.       short base;        /* base for [diouxX] conversion */
  1019.       short dprec;        /* decimal precision in [diouxX] */
  1020. ***************
  1021. *** 247,253 ****
  1022. --- 272,286 ----
  1023.           case 'f':
  1024.           case 'g':
  1025.           case 'G':
  1026. + 
  1027. + /* mjr: check for NANs */
  1028. + #define    _double _dd.d
  1029.               _double = va_arg(argp, double);
  1030. +             if( (unsigned long)_dd.i[0] == __notanumber[0])    {
  1031. +                 t = strcpy(t, " Not A Number ");
  1032. +                 size = strlen(t);
  1033. +                 goto pforw;
  1034. +             }
  1035.               /*
  1036.                * don't do unrealistic precision; just pad it with
  1037.                * zeroes later, so buffer size stays rational.
  1038. ***************
  1039. *** 269,274 ****
  1040. --- 302,320 ----
  1041.               }
  1042.               else
  1043.                   softsign = 0;
  1044. + /* mjr: check for +-INFINITY */
  1045. +             if(
  1046. +                 ((unsigned long)_dd.i[0] == __p_infinity[0])
  1047. + /*              && ((unsigned long)_dd.i[1] == __p_infinity[1]) */
  1048. + /* mjr: don't test this in order to catch a conversion bug in gcc-as     */
  1049. +             )    {
  1050. +             if(softsign == 0)
  1051. +                 t = strcpy(t, " Infinity ");
  1052. +             else
  1053. +                 t = strcpy(t, " -Infinity ");
  1054. +                 size = strlen(t);
  1055. +                 goto pforw;
  1056. +             }
  1057.               /*
  1058.                * cvt may have to round up past the "start" of the
  1059.                * buffer, i.e. ``intf("%.2f", (double)9.999);'';
  1060. ***************
  1061. *** 321,327 ****
  1062.   #ifdef __GNUC__
  1063.                   char *p;
  1064.                   void *memchr(const void *, int, size_t);
  1065. - 
  1066.   #else
  1067.                   char *p, *memchr();
  1068.   #endif
  1069. --- 367,372 ----
  1070. *** 1.8    1991/12/26 15:53:59
  1071. --- fdopen.c    1992/02/04 17:16:08
  1072. ***************
  1073. *** 3,11 ****
  1074.   #include <stdio.h>
  1075.   #include <fcntl.h>
  1076.   #include <unistd.h>
  1077.   
  1078. - extern    FILE    _iob[];
  1079. - 
  1080.   FILE *fdopen(h, mode)
  1081.       register int h;
  1082.       const register char *mode;
  1083. --- 3,10 ----
  1084.   #include <stdio.h>
  1085.   #include <fcntl.h>
  1086.   #include <unistd.h>
  1087. + #include <errno.h>
  1088.   
  1089.   FILE *fdopen(h, mode)
  1090.       register int h;
  1091.       const register char *mode;
  1092. ***************
  1093. *** 19,25 ****
  1094.           if(!(_iob[i]._flag & (_IORW | _IOREAD | _IOWRT)))
  1095.               fp = &_iob[i];    /* empty slot */
  1096.       if(!fp)
  1097. !         return(NULL);
  1098.       while(*mode)
  1099.           {
  1100.           switch(*mode++)
  1101. --- 18,27 ----
  1102.           if(!(_iob[i]._flag & (_IORW | _IOREAD | _IOWRT)))
  1103.               fp = &_iob[i];    /* empty slot */
  1104.       if(!fp)
  1105. !       {
  1106. !         errno = EMFILE;
  1107. !         return(NULL);
  1108. !       }
  1109.       while(*mode)
  1110.           {
  1111.           switch(*mode++)
  1112. *** 1.15    1991/12/26 15:53:59
  1113. --- fopen.c    1992/02/04 17:16:09
  1114. ***************
  1115. *** 4,9 ****
  1116. --- 4,10 ----
  1117.   #include <stdlib.h>
  1118.   #include <fcntl.h>
  1119.   #include <unistd.h>
  1120. + #include <errno.h>
  1121.   #ifndef _COMPILER_H
  1122.   #include <compiler.h>
  1123.   #endif
  1124. ***************
  1125. *** 97,103 ****
  1126.           return fp;
  1127.       }
  1128.       else
  1129. !         return NULL;
  1130.       }
  1131.   
  1132.   /*
  1133. --- 98,107 ----
  1134.           return fp;
  1135.       }
  1136.       else
  1137. !       {
  1138. !         errno = EMFILE;
  1139. !         return NULL;
  1140. !       }
  1141.       }
  1142.   
  1143.   /*
  1144. *** 1.10    1991/04/23 16:04:12
  1145. --- fputc.c    1992/02/04 17:16:10
  1146. ***************
  1147. *** 50,54 ****
  1148.           c = '\n';
  1149.           goto _fputc;
  1150.           }
  1151. !     return(c);
  1152.       }
  1153. --- 50,54 ----
  1154.           c = '\n';
  1155.           goto _fputc;
  1156.           }
  1157. !     return(c & 0xff);
  1158.       }
  1159. *** 1.8    1991/06/23 17:07:09
  1160. --- fscanf.c    1992/02/04 17:16:11
  1161. ***************
  1162. *** 5,10 ****
  1163. --- 5,14 ----
  1164.   #include <compiler.h>
  1165.   #endif
  1166.   
  1167. + #ifdef sun
  1168. + # define fungetc ungetc
  1169. + #endif
  1170. + 
  1171.   __EXTERN int _scanf __PROTO((FILE *fp, int (*get)(FILE *f),
  1172.                   int (*unget)(int c, FILE *s),
  1173.                   const char *fmt, va_list argp));
  1174. *** 1.8    1991/05/23 14:43:17
  1175. --- getpw.c    1992/02/04 17:16:13
  1176. ***************
  1177. *** 30,35 ****
  1178. --- 30,36 ----
  1179.   */
  1180.   
  1181.   #include <stdio.h>
  1182. + #include <types.h>
  1183.   #include <pwd.h>
  1184.   #include <unistd.h>
  1185.   #include <support.h>
  1186. ***************
  1187. *** 90,97 ****
  1188.           return (& curentry);
  1189.   }
  1190.   
  1191.   struct passwd *getpwuid (uid)
  1192. ! register int uid;
  1193.   {
  1194.       if (! setpwent ())
  1195.           return (NULL);
  1196. --- 91,102 ----
  1197.           return (& curentry);
  1198.   }
  1199.   
  1200. + #if __STDC__
  1201. + struct passwd *getpwuid (uid_t uid)
  1202. + #else
  1203.   struct passwd *getpwuid (uid)
  1204. ! uid_t uid;
  1205. ! #endif
  1206.   {
  1207.       if (! setpwent ())
  1208.           return (NULL);
  1209. ***************
  1210. *** 104,110 ****
  1211.   }
  1212.   
  1213.   struct passwd *getpwnam (name)
  1214. ! register char *name;
  1215.   {
  1216.       if (! setpwent ())
  1217.           return (NULL);
  1218. --- 109,115 ----
  1219.   }
  1220.   
  1221.   struct passwd *getpwnam (name)
  1222. ! register const char *name;
  1223.   {
  1224.       if (! setpwent ())
  1225.           return (NULL);
  1226. *** 1.12    1991/12/26 15:53:59
  1227. --- localtim.c    1992/02/04 17:16:17
  1228. ***************
  1229. *** 152,157 ****
  1230. --- 152,158 ----
  1231.   
  1232.       tzset();
  1233.           offset = *t - _timezone;
  1234. +     if(offset < 0) offset = 0; /* this is questionable */
  1235.           stm = _gmtime(&offset, <im);
  1236.       if (stm == NULL) return stm;        /* check for illegal time */
  1237.           stm->tm_isdst = (dst == -1) ? -1 : 0;
  1238. *** 1.20    1991/12/26 15:53:59
  1239. --- main.c    1992/02/04 17:16:17
  1240. ***************
  1241. *** 116,123 ****
  1242.           _getbuf(f);    /* get a buffer */
  1243.       }
  1244.   
  1245. !     for(i = 0; i <= __OPEN_INDEX(2); i++) {
  1246. !         __open_stat[i].filename = isatty(i) ? 
  1247.               ((_console_dev == 2) ? "/dev/console" : "/dev/tty1")
  1248.                   : (char *)NULL; /* if it was re-dir */
  1249.       }
  1250. --- 116,123 ----
  1251.           _getbuf(f);    /* get a buffer */
  1252.       }
  1253.   
  1254. !     for(i = 0; i <= 2; i++) {
  1255. !         __open_stat[__OPEN_INDEX(i)].filename = isatty(i) ? 
  1256.               ((_console_dev == 2) ? "/dev/console" : "/dev/tty1")
  1257.                   : (char *)NULL; /* if it was re-dir */
  1258.       }
  1259. *** 1.18    1991/12/26 15:53:59
  1260. --- malloc.c    1992/02/04 17:16:18
  1261. ***************
  1262. *** 76,85 ****
  1263.       if (((long)q) == -1)         /* can't alloc any more? */
  1264.           return(NULL);
  1265.   
  1266. !     p->next = q;
  1267.       q->size = sz;
  1268. !     q->next = NULL;
  1269.       q->valid = VAL_FREE;
  1270.       }
  1271.           
  1272.     if (q->size > n + sizeof(struct mem_chunk))
  1273. --- 76,89 ----
  1274.       if (((long)q) == -1)         /* can't alloc any more? */
  1275.           return(NULL);
  1276.   
  1277. !     /* Note: q may be below the highest allocated chunk */
  1278. !     p = &_mchunk_free_list;
  1279. !     while (p->next != NULL && q > p->next)
  1280. !       p = p->next;
  1281.       q->size = sz;
  1282. !     q->next = p->next;
  1283.       q->valid = VAL_FREE;
  1284. +     p->next = q;
  1285.       }
  1286.           
  1287.     if (q->size > n + sizeof(struct mem_chunk))
  1288. ***************
  1289. *** 157,177 ****
  1290.       r->size = 0;
  1291.       r->next = NULL;
  1292.       s = (struct mem_chunk * )(((long) p) + p->size);
  1293. !     if ((!_split_mem) && _heapbase != NULL && s >= (struct mem_chunk *) _heapbase) {
  1294.         assert(s == _heapbase);
  1295.         _heapbase = (char *) p;
  1296.         _stksize += p->size;
  1297. !       o->next = NULL;    /* o is always != NULL here */
  1298.       }
  1299.       }
  1300.       else
  1301.           {
  1302.         s = (struct mem_chunk * )(((long) r) + r->size);
  1303. !       if ((!_split_mem) && _heapbase != NULL && s >= (struct mem_chunk *) _heapbase) {
  1304.           assert(s == _heapbase);
  1305.           _heapbase = (char *) r;
  1306.           _stksize += r->size;
  1307. !         p->next = NULL;
  1308.         } else p->next = r;
  1309.       }
  1310.   }
  1311. --- 161,185 ----
  1312.       r->size = 0;
  1313.       r->next = NULL;
  1314.       s = (struct mem_chunk * )(((long) p) + p->size);
  1315. !     if ((!_split_mem) && _heapbase != NULL &&
  1316. !         s >= (struct mem_chunk *) _heapbase &&
  1317. !         s < (struct mem_chunk *) (_heapbase + _stksize)) {
  1318.         assert(s == _heapbase);
  1319.         _heapbase = (char *) p;
  1320.         _stksize += p->size;
  1321. !       o->next = p->next;    /* o is always != NULL here */
  1322.       }
  1323.       }
  1324.       else
  1325.           {
  1326.         s = (struct mem_chunk * )(((long) r) + r->size);
  1327. !       if ((!_split_mem) && _heapbase != NULL &&
  1328. !           s >= (struct mem_chunk *) _heapbase &&
  1329. !           s < (struct mem_chunk *) (_heapbase + _stksize)) {
  1330.           assert(s == _heapbase);
  1331.           _heapbase = (char *) r;
  1332.           _stksize += r->size;
  1333. !         p->next = r->next;
  1334.         } else p->next = r;
  1335.       }
  1336.   }
  1337. *** 1.14    1992/01/14 18:46:50
  1338. --- mincl    1992/02/04 17:16:19
  1339. ***************
  1340. *** 79,93 ****
  1341.       $(CC) $(CFFLAGS) -c fork.c
  1342.   
  1343.   #
  1344. ! # setjmp, div, _normdf, ldexp, frexp must be pre-processed
  1345.   %.s : %.cpp
  1346.       $(CPP) $(PPFLAGS) $< $@
  1347.   
  1348.   setjmp.o : setjmp.cpp
  1349.   div.o : div.cpp
  1350. ! _normdf.o : _normdf.cpp
  1351. ! ldexp.o : ldexp.cpp
  1352. ! frexp.o : frexp.cpp
  1353.   
  1354.   #
  1355.   # integer only io stuff
  1356. --- 79,107 ----
  1357.       $(CC) $(CFFLAGS) -c fork.c
  1358.   
  1359.   #
  1360. ! # Assembler stuff that needs to be preprocessed by cpp into a .S
  1361. ! #
  1362.   %.s : %.cpp
  1363.       $(CPP) $(PPFLAGS) $< $@
  1364.   
  1365.   setjmp.o : setjmp.cpp
  1366.   div.o : div.cpp
  1367. ! _addsubd.o: _addsubd.cpp
  1368. ! _addsubs.o: _addsubs.cpp
  1369. ! _divdf3.o: _divdf3.cpp
  1370. ! _divsf3.o: _divsf3.cpp
  1371. ! _extends.o: _extends.cpp
  1372. ! _fixdfsi.o: _fixdfsi.cpp
  1373. ! _floatsi.o: _floatsi.cpp
  1374. ! _fxunsd.o: _fxunsd.cpp
  1375. ! _muldf3.o: _muldf3.cpp
  1376. ! _mulsf3.o: _mulsf3.cpp
  1377. ! _normdf.o: _normdf.cpp
  1378. ! _normsf.o: _normsf.cpp
  1379. ! _truncdf.o: _truncdf.cpp
  1380. ! frexp.o: frexp.cpp
  1381. ! ldexp.o: ldexp.cpp
  1382. ! modf.o: modf.cpp
  1383.   
  1384.   #
  1385.   # integer only io stuff
  1386. ***************
  1387. *** 103,109 ****
  1388.   
  1389.   # other dependencies
  1390.   bcopy.o : bcopy.s
  1391. - modf.o  : modf.s
  1392.   atof.o  : flonum.h
  1393.   
  1394.   #
  1395. --- 117,122 ----
  1396. ***************
  1397. *** 129,135 ****
  1398.       rm -f $(ANSI)
  1399.       rm -f $(PORT)
  1400.       rm -f $(IIOBJ)
  1401. !     rm -f setjmp.s div.s _normdf.s ldexp.s frexp.s
  1402.   
  1403.   realclean: clean
  1404.       rm -f $(ALL) $(ALL020)
  1405. --- 142,151 ----
  1406.       rm -f $(ANSI)
  1407.       rm -f $(PORT)
  1408.       rm -f $(IIOBJ)
  1409. !     rm -f setjmp.s div.s
  1410. !     rm -f _addsubd.s _addsubs.s _divdf3.s _divsf3.s _extends.s _fixdfsi.s
  1411. !     rm -f _floatsi.s _fxunsd.s _muldf3.s _mulsf3.s _normdf.s _normsf.s
  1412. !     rm -f _truncdf.s frexp.s ldexp.s modf.s
  1413.   
  1414.   realclean: clean
  1415.       rm -f $(ALL) $(ALL020)
  1416. *** 1.2    1991/12/26 15:53:59
  1417. --- pipe.c    1992/02/04 17:16:22
  1418. ***************
  1419. *** 2,14 ****
  1420.   #include <stat.h>
  1421.   #include <types.h>
  1422.   #include <errno.h>
  1423. - #include <stdio.h>
  1424.   #include <stdlib.h>
  1425.   #define __MINT__
  1426.   #include <mintbind.h>
  1427.   
  1428.   extern int __mint;
  1429.   
  1430.   /**
  1431.    ** (sjk)++ These routines simulate a eunchs pipe() call using temporary 
  1432.    **         files. A linked list of type *_pipe is kept as to allow as 
  1433. --- 2,25 ----
  1434.   #include <stat.h>
  1435.   #include <types.h>
  1436.   #include <errno.h>
  1437.   #include <stdlib.h>
  1438. + #include <unistd.h>
  1439. + #include <string.h>
  1440.   #define __MINT__
  1441.   #include <mintbind.h>
  1442.   
  1443. + 
  1444.   extern int __mint;
  1445.   
  1446. + #if defined(DEBUG)
  1447. + #  include <stdio.h>
  1448. + #endif
  1449. + 
  1450. + #ifndef _COMPILER_H
  1451. + #  include <compiler.h>
  1452. + #endif
  1453. + __EXTERN char *tmpnam __PROTO((char *buf));
  1454. + 
  1455.   /**
  1456.    ** (sjk)++ These routines simulate a eunchs pipe() call using temporary 
  1457.    **         files. A linked list of type *_pipe is kept as to allow as 
  1458. ***************
  1459. *** 29,34 ****
  1460. --- 40,48 ----
  1461.   static struct _pipe *__pipes = NULL;
  1462.   static int del_list (struct _pipe *);
  1463.   
  1464. + __EXTERN int pipeclose __PROTO((int fd));
  1465. + extern int (*pipeclose_p) __PROTO((int fd));
  1466. + 
  1467.   /*---------------------------------------------------------------------------*/
  1468.   /* Make a pipe, open the tempory file, set it up for writing, add the pipe   */
  1469.   /* descriptor to our linked list of pipes, and return.                       */
  1470. ***************
  1471. *** 35,45 ****
  1472.   /*---------------------------------------------------------------------------*/
  1473.   int pipe(fildes)
  1474.   int fildes[2];
  1475. ! { int       fd,ifd; 
  1476.     char name[40];
  1477.     struct _pipe *p;
  1478.   
  1479. !   tmpnam(name);                              /* Make a temporary file name. /*
  1480.     
  1481.     /*----------------------------------------------*/
  1482.     /* Open the pipe for reading and writing.       */
  1483. --- 49,59 ----
  1484.   /*---------------------------------------------------------------------------*/
  1485.   int pipe(fildes)
  1486.   int fildes[2];
  1487. ! { int       fd; 
  1488.     char name[40];
  1489.     struct _pipe *p;
  1490.   
  1491. !   tmpnam(name);                              /* Make a temporary file name. */
  1492.     
  1493.     /*----------------------------------------------*/
  1494.     /* Open the pipe for reading and writing.       */
  1495. ***************
  1496. *** 51,57 ****
  1497. --- 65,75 ----
  1498.   #endif
  1499.   
  1500.     if (fd < 0)
  1501. + #if defined(DEBUG)
  1502.       fprintf(stderr,"fd returns : %d! PIPE(%s) failed.\n",fd, name);
  1503. + #else
  1504. +     /* nothing */;
  1505. + #endif
  1506.     else 
  1507.       { /*------------------------------------------*/
  1508.         /* Get a pipe description block and         */
  1509. ***************
  1510. *** 64,69 ****
  1511. --- 82,89 ----
  1512.         strcpy(p->p_name,name);           /* fill in name.                   */  
  1513.         p->flag = 'w';                    /* initially for write.            */
  1514.         p->file_des = fd;                 /* fill in the pipe descriptor.    */
  1515. +       if(!__pipes)
  1516. +     pipeclose_p = pipeclose;    /* patch in addr of close routine  */
  1517.         /*-------------------------------------------------------------------*/
  1518.         p->next = __pipes;                /* Link to our list of open pipes. */
  1519.         __pipes     = p;
  1520. ***************
  1521. *** 70,76 ****
  1522.         /*-------------------------------------------------------------------*/ 
  1523.         fildes[0] = fildes[1] = fd;       /* we fill in fildes[].            */
  1524.         if (__mint)
  1525. !     Fcntl(fd,0L,2);                 /* Make fd shared across Pexecs()  */
  1526.       }
  1527.     return(fd);                           /* Return the file descriptor.     */
  1528.   }
  1529. --- 90,96 ----
  1530.         /*-------------------------------------------------------------------*/ 
  1531.         fildes[0] = fildes[1] = fd;       /* we fill in fildes[].            */
  1532.         if (__mint)
  1533. !     (void) Fcntl(fd,0L,2);          /* Make fd shared across Pexecs()  */
  1534.       }
  1535.     return(fd);                           /* Return the file descriptor.     */
  1536.   }
  1537. ***************
  1538. *** 84,90 ****
  1539.   int
  1540.   pipeclose(fd)
  1541.   int fd;
  1542. ! {  struct _pipe *p,*q = NULL;
  1543.      int    ifd;
  1544.      for (p=__pipes; p; p=p->next)
  1545.       { if (fd == p->file_des) 
  1546. --- 104,110 ----
  1547.   int
  1548.   pipeclose(fd)
  1549.   int fd;
  1550. ! {  struct _pipe *p;
  1551.      int    ifd;
  1552.      for (p=__pipes; p; p=p->next)
  1553.       { if (fd == p->file_des) 
  1554. ***************
  1555. *** 109,115 ****
  1556. --- 129,137 ----
  1557.             }
  1558.         }
  1559.       }
  1560. + #if defined(DEBUG)
  1561.      fprintf(stderr,"attempt to close nonexistant pipe.\n");
  1562. + #endif
  1563.      return(-1);
  1564.   }
  1565.   
  1566. ***************
  1567. *** 136,141 ****
  1568. --- 158,165 ----
  1569.             q = r;                        /* update trailing pointer.    */
  1570.       }
  1571.       }
  1572. + #if defined(DEBUG)
  1573.     fprintf(stderr,"Attempt to delete a nonexisting pipe form list (__pipes).");
  1574. + #endif
  1575.     return(-1);
  1576.   }
  1577. *** 1.8    1991/12/26 15:53:59
  1578. --- sbrk.c    1992/02/04 17:16:24
  1579. ***************
  1580. *** 9,14 ****
  1581. --- 9,20 ----
  1582.      unlike Unix.
  1583.   */
  1584.   
  1585. + /* Further WARNING: in a split_mem model the memory addresses will NOT
  1586. +    be monotonous. sigh!  (i hate these mem models as much as the next
  1587. +    person. as usual, people at atari are totally oblivious to such
  1588. +    brain damage, even when pointed out to them. sigh!)
  1589. + */
  1590. + 
  1591.   #include <osbind.h>
  1592.   #include <unistd.h>
  1593.   #include <errno.h>
  1594. *** 1.12    1991/12/26 15:53:59
  1595. --- scanf.c    1992/02/04 17:16:25
  1596. ***************
  1597. *** 67,73 ****
  1598.   #define    inchar()    ((c = ((*get)(s))) == EOF ? EOF : (++read_in, c))
  1599.   #define unchar(c)    (--read_in, (*unget)(c, s))
  1600.   #define    conv_error()    return((c == EOF || ((*unget)(c, s))), done)
  1601. ! #define input_error()    return(-1)
  1602.   #define    memory_error()    return((errno = ENOMEM), EOF)
  1603.   
  1604.   
  1605. --- 67,73 ----
  1606.   #define    inchar()    ((c = ((*get)(s))) == EOF ? EOF : (++read_in, c))
  1607.   #define unchar(c)    (--read_in, (*unget)(c, s))
  1608.   #define    conv_error()    return((c == EOF || ((*unget)(c, s))), done)
  1609. ! #define input_error()    return( done < 1 ? EOF : done )
  1610.   #define    memory_error()    return((errno = ENOMEM), EOF)
  1611.   
  1612.   
  1613. ***************
  1614. *** 250,263 ****
  1615.           
  1616.           if (width == -1)
  1617.           width = 1;
  1618. !         
  1619. !         if (do_assign)
  1620. !         while (inchar() != EOF && width-- > 0)
  1621.               *str++ = c;
  1622. !         else
  1623. !         while (inchar() != EOF && width-- > 0)
  1624.               ;
  1625. !         
  1626.           if (do_assign)
  1627.           ++done;
  1628.           
  1629. --- 250,264 ----
  1630.           
  1631.           if (width == -1)
  1632.           width = 1;
  1633. ! /* mjr:    */        
  1634. !         if (do_assign) {
  1635. !         do
  1636.               *str++ = c;
  1637. !         while (inchar() != EOF && --width > 0);
  1638. !         } else
  1639. !         while (inchar() != EOF && --width > 0)
  1640.               ;
  1641. ! 
  1642.           if (do_assign)
  1643.           ++done;
  1644.           
  1645. *** 1.16    1991/12/26 15:53:59
  1646. --- stat.c    1992/02/04 17:16:28
  1647. ***************
  1648. *** 105,112 ****
  1649.       return d;
  1650.   }
  1651.   
  1652. ! int
  1653. ! stat(_path, st)
  1654.       const char    *_path;
  1655.       struct stat    *st;
  1656.   {
  1657. --- 105,112 ----
  1658.       return d;
  1659.   }
  1660.   
  1661. ! static int
  1662. ! _stat(_path, st)
  1663.       const char    *_path;
  1664.       struct stat    *st;
  1665.   {
  1666. ***************
  1667. *** 232,238 ****
  1668.       st->st_uid = geteuid();    /* the current user owns every file */
  1669.       st->st_gid = getegid();
  1670.       st->st_blksize = 1024;
  1671. !     return 0;
  1672.   }
  1673.   
  1674.   #include <fcntl.h>
  1675. --- 232,246 ----
  1676.       st->st_uid = geteuid();    /* the current user owns every file */
  1677.       st->st_gid = getegid();
  1678.       st->st_blksize = 1024;
  1679. !     return nval;
  1680. ! }
  1681. ! 
  1682. ! int
  1683. ! stat(path, st)
  1684. !     const char    *path;
  1685. !     struct stat    *st;
  1686. ! {
  1687. !     return _stat(path, st) < 0 ? -1 : 0;
  1688.   }
  1689.   
  1690.   #include <fcntl.h>
  1691. ***************
  1692. *** 336,367 ****
  1693.       const char *_path;
  1694.       struct stat *st;
  1695.   {
  1696. !     char path[FILENAME_MAX];
  1697. !     int n, r, linksiz;
  1698. !     SYMDIR *dir;
  1699. !     SYMENTRY *ent;
  1700.   
  1701.   /* unx2dos returns _NM_LINK if the last path component was a symbolic link
  1702.    * in this case, __link_name and __link_path are set to the name and path
  1703. !  * of the symbolic link file, and __link_to to its contents
  1704.    */
  1705. !     n = unx2dos(_path, path);
  1706. !     linksiz = strlen(__link_to);
  1707.   
  1708. !     if (n == _NM_LINK && _lAUTO && (dir = _read_symdir(__link_path))) {
  1709. !         ent = _symdir_lookup(dir, __link_name);
  1710. !         assert(ent != 0);
  1711. !         if (ent->flags & SD_AUTO)
  1712. !             n = _NM_OK;    /* pretend that it wasn't a link*/
  1713. !         _free_symdir(dir);
  1714. !     }
  1715. ! 
  1716. !     r = stat(_path, st);
  1717. ! 
  1718. !     if (n != _NM_LINK || r < 0)        /* not a symlink */
  1719.           return r;
  1720. !     st->st_size = linksiz;
  1721. !     st->st_blocks = (st->st_size + 1023)/1024;
  1722. !     st->st_mode = ((st->st_mode & ~S_IFMT) | S_IFLNK);
  1723.       return 0;
  1724.   }
  1725. --- 344,366 ----
  1726.       const char *_path;
  1727.       struct stat *st;
  1728.   {
  1729. !     int r;
  1730.   
  1731.   /* unx2dos returns _NM_LINK if the last path component was a symbolic link
  1732.    * in this case, __link_name and __link_path are set to the name and path
  1733. !  * of the symbolic link file, __link_to to its contents, and __link_flags
  1734. !  * its flags.
  1735.    */
  1736. !     r = _stat(_path, st);
  1737.   
  1738. !     if (r < 0)
  1739.           return r;
  1740. ! 
  1741. !     if (r == _NM_LINK && !(__link_flags & SD_AUTO))
  1742. !     {
  1743. !         st->st_size = strlen(__link_to);
  1744. !         st->st_blocks = 1;
  1745. !         st->st_mode = ((st->st_mode & ~S_IFMT) | S_IFLNK);
  1746. !     }
  1747.       return 0;
  1748.   }
  1749. *** 1.12    1991/06/11 23:04:27
  1750. --- system.c    1992/02/04 17:16:33
  1751. ***************
  1752. *** 6,11 ****
  1753. --- 6,15 ----
  1754.    * Modified by Allan Pratt to call unx2dos on redirect file names
  1755.    * and to call spawnvp() without calling fork() -- why bother?
  1756.    *
  1757. +  * Modified by Frank Ridderbusch in _parseargs() to handle the case
  1758. +  * >'file'. Without the modification, the quotes would end up in the
  1759. +  * filename for redirection
  1760. +  *
  1761.    */
  1762.   
  1763.   #include <stdio.h>
  1764. ***************
  1765. *** 78,84 ****
  1766.       const char *s;
  1767.   {
  1768.       Argentry *cur, *res;
  1769. !     char buf[FILENAME_MAX];
  1770.       char *t, quote;
  1771.   
  1772.       res = cur = _argalloc("");
  1773. --- 82,88 ----
  1774.       const char *s;
  1775.   {
  1776.       Argentry *cur, *res;
  1777. !     char buf[BUFSIZ];
  1778.       char *t, quote;
  1779.   
  1780.       res = cur = _argalloc("");
  1781. ***************
  1782. *** 95,102 ****
  1783.               if (*s) s++;    /* skip final quote */
  1784.           }
  1785.           else {
  1786. !             while (*s && !isspace(*s))
  1787.                   *t++ = *s++;
  1788.               if (*s && ( *(s-1) == '>' || *(s-1) == '<' ))
  1789.                   goto again;
  1790.           }
  1791. --- 99,109 ----
  1792.               if (*s) s++;    /* skip final quote */
  1793.           }
  1794.           else {
  1795. !             while (*s && !isspace(*s)) {
  1796.                   *t++ = *s++;
  1797. +                 if (isquote(*s))
  1798. +                     goto again;
  1799. +             }
  1800.               if (*s && ( *(s-1) == '>' || *(s-1) == '<' ))
  1801.                   goto again;
  1802.           }
  1803. *** 1.20    1991/12/26 15:53:59
  1804. --- unx2dos.c    1992/02/04 17:16:37
  1805. ***************
  1806. *** 305,311 ****
  1807.   #define MAXRECURSE 12
  1808.   
  1809.   char __link_path[FILENAME_MAX], __link_name[_LIB_NAME_MAX],
  1810. !     __link_to[_LIB_NAME_MAX];
  1811.   int __link_flags = 0;
  1812.   
  1813.   static int
  1814. --- 305,311 ----
  1815.   #define MAXRECURSE 12
  1816.   
  1817.   char __link_path[FILENAME_MAX], __link_name[_LIB_NAME_MAX],
  1818. !     __link_to[FILENAME_MAX];
  1819.   int __link_flags = 0;
  1820.   
  1821.   static int
  1822. ***************
  1823. *** 392,400 ****
  1824.       while (ent) {
  1825.           if (!strcmp(ent->linkname, name)) {
  1826.           change = _NM_LINK;
  1827. -         /* only set __link_to once */
  1828. -         if (!__link_to[0])
  1829. -             strcpy(__link_to, ent->linkto);
  1830.   #ifdef DEBUG
  1831.           printf("...following link (%s)->(%s)\n", name, ent->linkto);
  1832.   #endif
  1833. --- 392,397 ----
  1834. ***************
  1835. *** 401,406 ****
  1836. --- 398,404 ----
  1837.           
  1838.           if (level == 0) {
  1839.               strcpy(__link_path, result);
  1840. +             strcpy(__link_to, ent->linkto);
  1841.               __link_flags = ent->flags;
  1842.           }
  1843.           /*
  1844. ***************
  1845. *** 503,510 ****
  1846.           unx = (unx[6]) ? &unx[7] : &unx[6];
  1847.       }
  1848.       }
  1849. -     
  1850. -     __link_to[0]='\0';
  1851.       
  1852.       change = _canon(path, (char *)unx, dos, 0);
  1853.       /*
  1854. --- 501,506 ----
  1855. *** 1.15    1991/07/23 22:06:28
  1856. --- write.c    1992/02/04 17:16:37
  1857. ***************
  1858. *** 103,109 ****
  1859.           if (*s == '\r')
  1860.               __col_pos = 0;
  1861.               else
  1862. !         if (*s >= ' ' && *s < 0177)
  1863.               __col_pos++;
  1864.               else
  1865.           if (*s == '\t')
  1866. --- 103,109 ----
  1867.           if (*s == '\r')
  1868.               __col_pos = 0;
  1869.               else
  1870. !         if (*(unsigned char *)s >= ' ')
  1871.               __col_pos++;
  1872.               else
  1873.           if (*s == '\t')
  1874.